package org.openkoala.gqc.infra.util;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import javax.xml.transform.Source; 
import javax.xml.transform.stream.StreamSource; 
import javax.xml.validation.Schema; 
import javax.xml.validation.SchemaFactory; 
import javax.xml.validation.Validator;

import org.w3c.dom.Attr;
import org.w3c.dom.Comment;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;
import org.dom4j.io.OutputFormat; 
import org.dom4j.io.SAXReader; 
import org.dom4j.io.SAXValidator; 
import org.dom4j.io.XMLWriter; 
import org.dom4j.util.XMLErrorHandler; 
/**
 * xsd验证xml格式工具
 * @author hbikai
 *
 */
public class XmlUtil {
/**
 * 
 */
private XmlUtil(){

}

public static XmlNode getXmlNodeByXml(String filePath) throws SAXException, IOException, ParserConfigurationException{
	DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();  

	DocumentBuilder db = dbf.newDocumentBuilder();  
	Document doc = (Document) db.parse(new File("C:/Users/keji/Desktop/sjcj.001.001.02.xml"));  
	//获得根元素结点  
	Element root = ((org.w3c.dom.Document) doc).getDocumentElement(); 
	XmlNode xmlNode = new XmlNode();
	xmlNode = parseElement(root,xmlNode);  
	return xmlNode;
}

/*
 * 测试验证
 */
public static void main(String[] args) throws SAXException, IOException, ParserConfigurationException {
	
    String xmlFileName = "C:/Users/keji/Desktop/sjcj.001.001.02.xml";
    String xsdFileName = "C:/Users/keji/Desktop/sjcj.001.001.02.xsd";
//	ValidateXml.validateXMLByXSD(xmlFileName,xsdFileName);
	
	// step 1: 获得dom解析器工厂（工作的作用是用于创建具体的解析器）  
	DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();  

	DocumentBuilder db = dbf.newDocumentBuilder();  
	  
	Document doc = (Document) db.parse(new File("C:/Users/keji/Desktop/sjcj.001.001.02.xml"));  
	
	//获得根元素结点  
	Element root = ((org.w3c.dom.Document) doc).getDocumentElement(); 
	XmlNode xmlNode = new XmlNode();
	xmlNode=parseElement(root,xmlNode); 
	String ss = xmlNode.toEditHtmlString();
	ss=ss;
}

private static XmlNode parseElement(Element element,XmlNode xmlNode)  {  
    String tagName = element.getNodeName();  
    NodeList children = element.getChildNodes();  
    
    xmlNode.setTagName(tagName);
//    System.out.print("<" + tagName);  
      
    if("Document".equals(tagName)){
    	//element元素的所有属性所构成的NamedNodeMap对象，需要对其进行判断 
    	String prototype = "";
        NamedNodeMap map = element.getAttributes();  
        //如果该元素存在属性  
        if(null != map)  {
            for(int i = 0; i < map.getLength(); i++){  
                //获得该元素的每一个属性  
                Attr attr = (Attr)map.item(i);  
                String attrName = attr.getName();  
                String attrValue = attr.getValue();  
                
                prototype=prototype +  " " + attrName + "=\"" + attrValue + "\"";
//                System.out.print(" " + attrName + "=\"" + attrValue + "\"");  
            }  
        }
        xmlNode.setPrototype(prototype);
    }else{
    	if(xmlNode.getPath()==null){
    		xmlNode.setPath(tagName);
    	}else{
    		xmlNode.setPath(xmlNode.getPath()+"."+tagName);
    	}
    }
    xmlNode.setRowspan(0);
//    System.out.print(">");  
    
    List<XmlNode> xmlNodes = new ArrayList<XmlNode>(0);
//    System.out.print(" $$$$$$$$$$$$$$$$$ tagName:" + tagName + "_children.getLength(): " + children.getLength()+"_");  
    if(children.getLength()==1){
    	xmlNode.setRowspan(1);
    }
    for(int i = 0; i < children.getLength(); i++)  {  
        Node node = children.item(i);  
        //获得结点的类型  
        short nodeType = node.getNodeType();  
          
        if(nodeType == Node.ELEMENT_NODE)  {  
            //是元素，继续递归 
        	XmlNode newNode = new XmlNode();
        	newNode.setPath(xmlNode.getPath());
        	newNode = parseElement((Element)node,newNode); 
        	xmlNode.setRowspan(xmlNode.getRowspan()+newNode.getRowspan());
        	xmlNodes.add(newNode);
        }  
        else if(nodeType == Node.TEXT_NODE)  {  
            //递归出口 
        	xmlNode.setValue(node.getNodeValue());
//            System.out.print(node.getNodeValue());  
        }
//        else if(nodeType == Node.COMMENT_NODE) {  
//            System.out.print("<!--");  
//            Comment comment = (Comment)node;  //注释内容  
//            String data = comment.getData();  
//            System.out.print(data);  
//            System.out.print("-->");  
//        }  
    }  
    xmlNode.setNodes(xmlNodes);
//    xmlNode.setRowspan(xmlNode.getRowspan()-xmlNodes.size());
//    System.out.print("</" + tagName + ">");  
    
    return xmlNode;
}  


/** 
 * 通过XSD（XML Schema）校验XML 
 */ 
public static Boolean validateXMLByXSD(String xmlFileName,String xsdFileName) { 
    try { 
        //创建默认的XML错误处理器 
        XMLErrorHandler errorHandler = new XMLErrorHandler(); 
        //获取基于 SAX 的解析器的实例 
        SAXParserFactory factory = SAXParserFactory.newInstance(); 
        //解析器在解析时验证 XML 内容。 
        factory.setValidating(true); 
        //指定由此代码生成的解析器将提供对 XML 名称空间的支持。 
        factory.setNamespaceAware(true); 
        //使用当前配置的工厂参数创建 SAXParser 的一个新实例。 
        SAXParser parser = factory.newSAXParser(); 
        //创建一个读取工具 
        SAXReader xmlReader = new SAXReader(); 
        //获取要校验xml文档实例 
      Document xmlDocument = (Document) xmlReader.read(new File(xmlFileName)); 
        //设置 XMLReader 的基础实现中的特定属性。核心功能和属性列表可以在 [url]http://sax.sourceforge.net/?selected=get-set[/url] 中找到。 
        parser.setProperty( 
                "http://java.sun.com/xml/jaxp/properties/schemaLanguage", 
                "http://www.w3.org/2001/XMLSchema"); 
        parser.setProperty( 
                "http://java.sun.com/xml/jaxp/properties/schemaSource", 
                "file:" + xsdFileName); 
        //创建一个SAXValidator校验工具，并设置校验工具的属性 
        SAXValidator validator = new SAXValidator(parser.getXMLReader()); 
        //设置校验工具的错误处理器，当发生错误时，可以从处理器对象中得到错误信息。 
        validator.setErrorHandler(errorHandler); 
        //校验 
//        validator.validate(xmlDocument); 

        XMLWriter writer = new XMLWriter(OutputFormat.createPrettyPrint()); 
        //如果错误信息不为空，说明校验失败，打印错误信息 
        if (errorHandler.getErrors().hasContent()) { 
            System.out.println("XML文件通过XSD文件校验失败！"); 
            writer.write(errorHandler.getErrors()); 
            return false;
        } else { 
            System.out.println("Success! XML文件通过XSD文件校验成功！"); 
            return true;
        } 
    } catch (Exception ex) { 
//        System.out.println("XML文件: " + xmlFileName + " 通过XSD文件:" + xsdFileName + "检验失败。\n原因： " + ex.getMessage()); 
        System.out.println("XML文件:  通过XSD文件:" + xsdFileName + "检验失败。\n原因： " + ex.getMessage()); 
        ex.printStackTrace(); 
    }
	return false; 
} 

public static boolean Validatexml(String xsdpath,String xmlpath) throws SAXException,IOException{
   //建立schema工厂
   SchemaFactory schemaFactory=SchemaFactory.newInstance("http://www.w3.org/2001/XMLSchema");
   //建立验证文档文件对象，利用此文件对象所封装的文件进行schema验证
   File schemaFile=new File(xsdpath);
   //利用schema工厂，接收验证文档文件对象生成Schema对象
   Schema schema=schemaFactory.newSchema(schemaFile);
   //通过Schema产生针对于此Schema的验证器，利用schenaFile进行验证
   Validator validator=schema.newValidator();
   //得到验证的数据源
   Source source=new StreamSource(xmlpath);
   //开始验证，成功输出success!!!，失败输出fail
   try{
    validator.validate(source); 
    
   }catch(Exception ex){
    
    ex.printStackTrace(); 
    
   }
         return true;
 }
}
